/* @name：资质合并计算（多个资质合并）
	@parameter:originalData 多个资质的数组，参考下面传入格式示例
	@parameter:industryId  当前行业大类id
//传入格式示例
let originalData = [
	{
		'高级水果':{
			count:10,   //总数
			type:'水果',  //分类类别
			typeLevel:3,   //分类级别
			any:1,     //无限制数量，当前类别任意一种类别 （和可选unknown数据不会同时存在）
			anyId:"158",     //无限制id
			data:{'苹果':4,'香蕉':3,'橘子':2}     //固定的类别数量
		},
		'初级水果':{
			count:15,   //总数
			type:'水果',
			typeLevel:1,
			data:{'苹果':4,'柚子':4,'香蕉':3,'橘子':2},     //固定的类别数量
			unknown:['香蕉','桃子','橘子'],   //三个类别其中一个即可（和无限制数据不会同时存在）
			unknownCount:2        //三个类别的数量
		},
		'高级蔬菜':{
			count:15,
			type:'蔬菜',
			typeLevel:3,
			data:{'茄子':3,'豆角':6},
			unknown:['萝卜','白菜','芹菜'],   //三个类别其中一个即可（和无限制数据不会同时存在）
			unknownCount:6        //三个类别的数量
		}
	},
	{
		'初级水果':{
			count:7,
			type:'水果',
			typeLevel:1,
			data:{'橘子':5},
			unknown:['香蕉','西瓜','桃子'],
			unknownCount:2
		},
		'中级蔬菜':{
			count:12,
			type:'蔬菜',
			typeLevel:2,
			any:2,
			anyId:"168",
			data:{'芹菜':1,'豆角':7,'茄子':2}
		},
		'动物':{
			count:9,
			data:{'小狗':4,'小猫':3,'小鸟':2}
		}
	},
	{
		'高级水果':{
			count:25,
			type:'水果',
			typeLevel:3,
			any:20,
			anyId:"158",
			data:{'苹果':5}
		},
		'初级蔬菜':{
			count:15,
			type:'蔬菜',
			typeLevel:1,
			any:10,
			anyId:"168",
			data:{'萝卜':3,'芹菜':2},
		}
	}
];
*/
import computeBeijing from "@/libs/compute-beijing.js";
export default function(originalData,industryId){
	if( !originalData || originalData.length<1 ){
		return ''
	};
	/* ---------- 将原始数据添加混淆防止js对象的key自动排序 ------------ */
	let objKeyStr = 'id';
	function addStr(strVal){
		return objKeyStr+strVal+objKeyStr;
	}
	function deleteStr(strVal){
		return strVal.replace(objKeyStr,'').replace(objKeyStr,'');
	}
	let newOriginalData = [];
	originalData.forEach((item,index)=>{
		let myItemObj = {};
		Object.keys(item).forEach(itemKey=>{
			let endObj = item[itemKey];
			let myObj = {};
			Object.keys(endObj).forEach(endKey=>{
				if( endKey=='data' ){
					let myDataObj = {},
						endObjData = endObj.data;
					Object.keys(endObj.data).forEach(endDataKey=>{
						myDataObj[addStr(endDataKey)] = endObjData[endDataKey];
					});
					myObj.data = myDataObj;
				}else if( endKey=='unknown' ){
					let myUnknown = [];
					endObj.unknown.forEach(item=>{
						myUnknown.push(addStr(item));
					});
					myObj.unknown = myUnknown;
				}else if( endKey=='anyId' ){
					myObj.anyId = addStr(endObj[endKey]);
				}else{
					myObj[endKey] = endObj[endKey];
				}
			});
			myItemObj[addStr(itemKey)] = myObj;
		});
		newOriginalData.push(myItemObj);
	});
	originalData = newOriginalData;
	
	/* ----------  按照分类分组后的初始对象数据 ------------ */
	let getKeysObj = {};
	originalData.forEach(item=>{
		Object.assign(getKeysObj,item);
	});
	let countKeys = Object.keys(getKeysObj);
	let originalMergeData = {};  //初始对象数据
	countKeys.forEach(key=>{
		originalMergeData[key] = [];
	});
	let hasLevelObj = {},   //需要级别合并的对象
		noLevelArr = [];   //无级别的分类数组
	originalData.forEach(item=>{
		Object.keys(item).forEach(key=>{
			originalMergeData[key].push(item[key]);
			let itemType = item[key].type || "";
			if( itemType ){
				hasLevelObj[key] = {
					type: itemType,
					typeLevel: item[key].typeLevel
				}
			}else{
				noLevelArr.push(key);
			}
		});
	});
	console.log('分组后的初始对象',originalMergeData);
	/*console.log('需要级别合并的对象',hasLevelObj);
	console.log('无级别的分类数组',noLevelArr);
	//进行级别合并
	let noMergeLevelObj = {};
	countKeys.forEach(item=>{
		noMergeLevelObj[item] = mergeFun(originalMergeData[item]);
	});
	console.log('未合并级别的数据',noMergeLevelObj);
	let groupLevelObj = {};
	let sortGroupKeys = Object.keys(hasLevelObj).sort((a, b) => {
			return hasLevelObj[b].typeLevel - hasLevelObj[a].typeLevel;
		});
	sortGroupKeys.forEach(key=>{
		let type = hasLevelObj[key].type;
		if( !groupLevelObj[type] ){
			groupLevelObj[type] = [];
		};
		groupLevelObj[type].push(noMergeLevelObj[key]);
	});
	console.log('级别分组后的数据（不含无级别）',groupLevelObj);*/

	/* ----------  最终所有类别集合（最终值） ------------ */
	let endObjData = {};
	countKeys.forEach(item=>{
		let endObjItem = mergeFun(originalMergeData[item]);
		Object.keys(endObjItem).forEach(elKey=>{
			endObjData[deleteStr(item)+"-"+deleteStr(elKey)] = endObjItem[elKey];
		})
	});

	/* ----------  如果是北京建筑行业，需要再次合并 ------------ */
	if(industryId==12 && uni.getStorageSync('addr')=='北京市'){
		// endObjData = {
		// 	'20-54':8,    //工程师-给排水
		// 	'20-53':2,   //工程师-暖通
			
		// 	'11-2':1,    //一级建造师
		// 	'12-2':1,    //二级建造师
		// 	'20-354':5,  //工程师-工业设计
		// 	'20-355':1,  //工程师-雕塑
			
		// 	// '11-1':1,    //一级建造师
		// 	'12-1':5,    //二级建造师
		// 	'20-40':2,    //工程师-燃气
		// 	// '20-100':10,
		// 	// '20-150':15,
		// 	// '11-17':1
		// };
		console.log('-----北京计算前数据',{...endObjData});
		//1.建筑工程专业一级注册建造师的情况
		endObjData = computeBeijing(
			originalData,  //多资质的原数据
			endObjData,  //北京计算前的数据
			'11-2',  //一级建造师-建筑工程id
			'12-2',  //二级建造师-建筑工程id
			['20-54','20-53','20-55','20-349','20-350','20-351','20-352','20-353','20-354','20-355'].reverse()  //可去除的工程师（给排水、暖通、结构、建筑学、环境艺术、室内设计、装潢设计、舞美设计、工业设计、雕塑）
		);
		//2.市政公用工程一级注册建造师的情况
		endObjData = computeBeijing(
			originalData,  //多资质的原数据
			endObjData,  //北京计算前的数据
			'11-1',  //一级建造师-市政公用工程id
			'12-1',  //二级建造师-市政公用工程id
			['20-54','20-41','20-40'].reverse()  //可去除的工程师（给排水、道路与桥梁、燃气）
		);
		//3.机电工程一级注册建造师的情况
		endObjData = computeBeijing(
			originalData,  //多资质的原数据
			endObjData,  //北京计算前的数据
			'11-17',  // 一级建造师-机电工程id
			'12-17',  //二级建造师-机电工程id
			['20-54','20-53','20-52','20-47','20-46','20-44','20-95','20-96','20-97','20-98','20-99','20-100','20-101'].reverse()  //可去除的工程师（给排水、暖通、电气、机械设备、焊接、自动化控制、热能动力工程、水能动力工程、核电工程、风电、太阳能及其他能源工程、输配电及用电工程、电力系统及其自动化）
		);
	};
	console.log('-----最终数据',endObjData);
	return endObjData;
	
	/* ----------  单个类目合并计算 ------------ */
	function mergeFun(allData){
		var knownObj = {},
			knownArr = [];
		(function(){
			//1-1遍历得到单选里面排重的对象
			for( var index in allData ){
				var listKnownObj = allData[index].data;
				if( listKnownObj ){
					var listKnownArr = Object.keys(listKnownObj);
					for( var i in listKnownArr ){
						var key = listKnownArr[i];
						if( !knownObj[key] || listKnownObj[key]>knownObj[key] ){
							knownObj[key] = listKnownObj[key]
						};
					};
				};
			};
			//1-2根据对象的值倒叙，并得到一个倒叙的数序
			var sortArr = Object.values(knownObj).sort((a, b) => {
				return b - a;
			});
			var sortObj = {};
			for( var sortItem in sortArr ){
				Object.keys(knownObj).map((item, index) => {
					if(knownObj[item] == sortArr[sortItem]){
						sortObj[item] = sortArr[sortItem];
					}
				});
			};
			knownObj = sortObj;
			knownArr = Object.keys(knownObj);
		})();
		// console.log("单选排序",knownObj,knownArr);
		// 2得到多选的排重并倒叙的对象
		var unknownObj = {},
			unknownArr = [];
		(function(){
			//2-1遍历未选数据，得到所有可能出现的最多工种
			for( var allIndex in allData ){
				var allItem = allData[allIndex];
				for( var i in allItem.unknown ){
					var unknownType = allItem.unknown[i];
					unknownObj[unknownType] = 0;
					if( allItem.unknownCount>unknownObj[unknownType] ){
						unknownObj[unknownType] = allItem.unknownCount;
					};
				};
			};
			//2-2根据对象的值倒叙，并得到一个倒叙的数序
			var sortArr = Object.values(unknownObj).sort((a, b) => {
				return b - a;
			});
			var sortObj = {};
			for( var sortItem in sortArr ){
				Object.keys(unknownObj).map((item, index) => {
					if(unknownObj[item] == sortArr[sortItem]){
						sortObj[item] = sortArr[sortItem];
					}
				});
			};
			unknownObj = sortObj;
			unknownArr = Object.keys(unknownObj);
		})();
		//console.log("多选排序",unknownObj,unknownArr);
		//3根据单选和多选排序的类别，依次确定资质里多个的类别
		(function(){
			for( var index in allData ){
				var unknownListArr = allData[index].unknown;
				var unknownIndexArr = [],
					unknownIndexArr2 = [];
				for( var i in unknownListArr ){
					unknownIndexArr.push(knownArr.indexOf(unknownListArr[i]));
					unknownIndexArr2.push(unknownArr.indexOf(unknownListArr[i]));
				};
				//3-1根据单选倒叙数据，取资质里面应选的类型
				var unknownIndex = 999;
				for( var j in unknownIndexArr ){
					var jVal = unknownIndexArr[j];
					if( jVal!=-1 && jVal<unknownIndex ){
						unknownIndex = jVal;
					};
				};
				//3-2根据多选倒叙数据，取资质里面应选的类型
				var unknownIndex2 = 999;
				for( var k in unknownIndexArr2 ){
					var kVal = unknownIndexArr2[k];
					if( kVal<unknownIndex2 ){
						unknownIndex2 = kVal;
					};
				};
				if( unknownIndex!=999 ){
					allData[index].computeType = knownArr[unknownIndex];
				}else if( unknownIndex2!=999 ){
					allData[index].computeType = unknownArr[unknownIndex2];
				};
			};
		})();
		//console.log("处理后的数据",allData);
		//4遍历数据，得到初次确定的类别和需要的真实数量
		(function(){
			for( var allIndex in allData ){
				var allItem = allData[allIndex],
					knownData = allItem.data,
					unknownData = allItem.unknown;
				if( unknownData ){
					var otherObj = {};
					var otherCount = 0;
					for( var i in unknownData ){
						var unknownI = unknownData[i];
						//得到除已确定多选类别外的其他类别
						if( unknownI!=allItem.computeType ){
							var knownObjI = knownObj[unknownI];
							if( knownObjI ){//如果整体单选里面有此类型
								if( knownData && knownData[unknownI] ){//如果资质单选里面有此类型
									if( knownObjI-knownData[unknownI] ){//整体单选减去资质单选
										otherObj[unknownI] = knownObjI-knownData[unknownI];
										otherCount+=knownObjI-knownData[unknownI];
									};
								}else{
									otherObj[unknownI] = knownObj[unknownI];//否则直接等于整体单选的值
									otherCount+=knownObj[unknownI];
								};
							};
						}else{//如果资质单选里面有已确定类型则扣除此值
							if( knownData && knownData[unknownI] ){
								otherCount-=knownData[unknownI];
							}
						}
					};
					if( Object.keys(otherObj).length ){
						allItem.otherObj = otherObj;
					};
					//allItem.otherCount = otherCount;
					//初次计算确定的类别需要的真实数量
					allItem.computeCount = allItem.unknownCount-otherCount;
				};
			};
		})();
		// console.log("初次计算的数据",allData);
		//5合并最终数量，得到初次合并的数据
		var endObj = JSON.parse(JSON.stringify(knownObj));
		(function(){
			for( var allIndex in allData ){
				var allItem = allData[allIndex],
					computeCount = allItem.computeCount,
					computeType = allItem.computeType;
				if( computeCount ){
					var endObjCount = endObj[computeType];
					if( endObjCount ){
						if( computeCount>endObjCount ){
							endObj[computeType] = computeCount;
						};
					}else{
						endObj[computeType] = computeCount;
					};
				};
			};
		})();
		// console.log("初次合并数据",endObj);
		//6和初次合并数据对比，再次计算每个资质需要的数量
		(function(){
			for( var allIndex in allData ){
				var allItem = allData[allIndex],
					knownData = allItem.data,
					unknownData = allItem.unknown;
				if( unknownData ){
					var other2Obj = {};
					var other2Count = 0;
					for( var i in unknownData ){
						var unknownI = unknownData[i];
						//得到除已确定多选类别外的其他类别
						if( unknownI!=allItem.computeType ){
							var endObjI = endObj[unknownI];
							if( endObjI ){//如果整体单选里面有此类型
								if( knownData && knownData[unknownI] ){//如果资质单选里面有此类型
									if( endObjI-knownData[unknownI] ){//整体单选减去资质单选
										other2Obj[unknownI] = endObjI-knownData[unknownI];
										other2Count+=endObjI-knownData[unknownI];
									};
								}else{
									other2Obj[unknownI] = endObj[unknownI];//否则直接等于整体单选的值
									other2Count+=endObj[unknownI];
								};
							};
						}else{//如果资质单选里面有已确定类型则扣除此值
							if( knownData && knownData[unknownI] ){
								other2Count-=knownData[unknownI];
							}
						}
					};
					if( Object.keys(other2Obj).length ){
						allItem.other2Obj = other2Obj;
					};
					//allItem.other2Count = other2Count;
					//计算最终确定的类别需要的真实数量
					allItem.compute2Count = allItem.unknownCount-other2Count;
				};
			};
		})();
		//7合并得到最终数据
		var typeOkObj = JSON.parse(JSON.stringify(knownObj));
		let anyCount = 0,    //合并后无限制总数
			anyId = '',    //无限制的id
			maxCertificate = 0;    //所有工种总数最大的资格证
		(function(){
			for( var allIndex in allData ){
				var allItem = allData[allIndex],
					compute2Count = allItem.compute2Count,
					computeType = allItem.computeType;
				if( compute2Count ){
					var typeOkObjCount = typeOkObj[computeType];
					if( typeOkObjCount ){
						if( compute2Count>typeOkObjCount ){
							typeOkObj[computeType] = compute2Count;
						};
					}else{
						typeOkObj[computeType] = compute2Count;
					};
				};
				//无限制的总数
				if( allItem.any>anyCount ){
					anyCount = allItem.any;
					anyId = allItem.anyId;
				};
				//所有工种总数最大的资格证
				if( allItem.count>maxCertificate ){
					maxCertificate = allItem.count;
				};
			};
		})();
		// console.log("未排除无限制的最终对象",typeOkObj);
		//8排除无限制的部分
		let allTypeCount = 0;    //合并后所有工种总数
		Object.values(typeOkObj).forEach(item=>{
			allTypeCount+=item;
		});
		let endAny = '';
		if( allTypeCount >= maxCertificate ){
			if( anyCount>allTypeCount ){
				endAny = anyCount - allTypeCount;
			}
		}else{
			endAny = maxCertificate - allTypeCount;
		};
		let endOkObj = {};
		if( endAny ){
			endOkObj = Object.assign({[anyId]:endAny},typeOkObj);
		}else{
			endOkObj = typeOkObj;
		}
		// console.log("最终单类别对象",endOkObj);
		return endOkObj;
	}
}